.include <reg51.def>
.include <reg535.def>
.segment Bits, sclass bit, org 20h
;Für die Festkommazahlausgabe
Fix_Flags: .ds.b 1 ;Steuerbits
Fix_Feldb: .ds.b 1 ;Feldbreite in Zeichen
Fix_Dezim: .ds.b 1 ;Dezimalstellen
.segment Daten, sclass dram, org 30h
CurDisplay: .ds.b 1 ;Für folgende Ausgabe aktive Display-Hälfte(n)
Num_Messung: .ds.b 1 ;mein 8-bit-Zähler
Produkt: .ds.l 1 ;das 16x16-Produkt
TMinMax: .ds.l 1 ;minimale (LOW) und maximale (HIGH) Temperatur
FMinMax: .ds.l 1 ;minimale (LOW) und maximale (HIGH) Feuchte
.segment start, org 0
;******************************************************************************
;** Wenn man beim Löten etwas Mist baut (hier: die Steuer- und Datenpins **
;** unglücklich verteilt), kann man's auch durch Software wieder hinbiegen, **
;** ist aber NICHT nachahmenswert! **
;** Verbleibenden Portpins werden rigoros auf den _gelesenen_ Pegel gesetzt, **
;** Vorsicht bei Eingängen! **
;******************************************************************************
DISP_DATA = P4 ; Port mit den 4 Datenleitungen (Nibble-Modus)
DATA0_BIT = 0
DATA1_BIT = 2
DATA2_BIT = 4
DATA3_BIT = 6
DATA0 = 1 << DATA0_BIT
DATA1 = 1 << DATA1_BIT
DATA2 = 1 << DATA2_BIT
DATA3 = 1 << DATA3_BIT
DISP_CONTROL = P5 ; Port mit den 4 Steuerleitungen
E_unten = 1 << 7 ; 1=Enable untere 2 Zeilen
E_oben = 1 << 6 ; 1=Enable obere 2 Zeilen
RW = 1 << 5 ; 0=Schreiben, 1=lesen
RS = 1 << 4 ; 0=Steuerbefehl, 1=Zeichen
Eu_BIT = DISP_CONTROL.7
Eo_BIT = DISP_CONTROL.6
RW_BIT = DISP_CONTROL.5
RS_BIT = DISP_CONTROL.4
SCK = P3.4 ; für SHT11
DATA = P3.5 ; für SHT11
ljmp init ;Reset-Vektor (keine Interrupts)
;******************************
;** Eine dumme Warteschleife **
;******************************
wait1:
;Wartet 1 Millisekunde
;PE: -
;PA: -
;VR: R5=0
MOV R5,#250
wait4xR5:
NOP ;1 Wartet R5*4µs
NOP ;1
DJNZ R5,wait4xR5 ;2 ;4µs*256=1ms
ret
;wait1 ENDP
wait:
;Wartet <R4> Millisekunden
acall wait1
djnz r4,wait
RET
;*******************************
;** Anzeige: LowLevel-Zugriff **
;*******************************
;PUBLIC disp_addr_in, disp_data_in, disp_ctrl_out, disp_char_out, disp_init_ll
disp_nib_in:
;1 Nibble vom Display einlesen
;PE: [CurDisplay]=E_unten _oder_ E_oben, RW_BIT=1 und RS_BIT schon gesetzt
;PA: a=gelesenes Nibble, High-Teil=0
;VR: a
mov a,DISP_DATA
orl a,#(DATA3|DATA2|DATA1|DATA0)
mov DISP_DATA,a ; alle Bits high = hochohmig
mov a,DISP_CONTROL
orl a,CurDisplay
mov DISP_CONTROL,a
nop ;Zeit bis zum Erscheinen der Daten t(DDR)=360ns
clr a
mov c,DISP_DATA.DATA3_BIT
rlc a
mov c,DISP_DATA.DATA2_BIT
rlc a
mov c,DISP_DATA.DATA1_BIT
rlc a
mov c,DISP_DATA.DATA0_BIT
rlc a
disp_disable:
clr Eu_BIT
clr Eo_BIT
ret
disp_data_in: ; Befehl "Read Data"
;PE: r2=E_oben _oder_ E_unten
;PA: a=gelesene Daten
;VR: a,b, RW_BIT=1, RS_BIT=1
setb RS_BIT
sjmp disp_byt_in
disp_addr_in: ; Befehl "Read Busy+Addr"
;PE: r2=E_oben _oder_ E_unten
;PA: a=gelesene Daten
;VR: a,b, RW_BIT=1, RS_BIT=0
clr RS_BIT
disp_byt_in:
;1 Byte vom Display einlesen
;PE: [CurDisplay] = E_oben _oder_ E_unten sowie RW=1 und RS wie gewünscht
;PA: a=gelesene Daten
;VR: a,r2
setb RW_BIT
acall disp_nib_in ;High-Nibble zuerst lesen
swap a
mov r2,a
acall disp_nib_in ;Low-Nibble danach lesen
orl a,r2
ret
disp_wait_ready: ;Wartet bis Display bereit zum Datenempfang
;VR: RW_BIT=1, RS_BIT=0, kann komplett blockieren!
push ACC
disp_warte:
acall disp_addr_in
jb ACC.7,disp_warte
pop ACC
ret
disp_char_out:
;1 Zeichen (mit RS=1) auf Display-Hälfte(n) ausgeben, wartet auf Bereitschaft
;PE: a=Zeichen (oder Zeile des Zeichenbildes) [CurDisplay]=Display-Hälften-Bit(s)
;PA: -
;VR: r2
acall disp_wait_ready
setb RS_BIT
sjmp disp_byt_out
disp_ctrl_out:
;1 Steuer-Byte (mit RS=0) auf Display-Hälfte(n) ausgeben, wartet auf Bereitschaft
;PE: a=Steuerbyte, [CurDisplay]=Display-Hälften-Bit(s)
;PA: -
;VR: r2
acall disp_wait_ready ;löscht RS bereits(!)
disp_byt_out:
;1 Byte auf Display ausgeben OHNE zu warten
;PE: a=Zeichen- oder Steuerbyte, RS_BIT nach Wunsch, [CurDisplay]=Bits
;PA: -
;VR: r2
clr RW_BIT ;immer "schreiben"
acall disp_nib_out
disp_nib_out: ;Ausgabe eines Nibbles <a> aufs Display(s) <r2> ohne auf Not-Busy warten
;PE: a=Zeichen- oder Steuer-Nibble IM HIGH-TEIL, r2="Steuerleitungen", also
; E_oben = oberen Controller ansprechen, E_unten = entsprechend, auch beide gleichzeitig möglich
; RS_BIT = Zeichenausgabe (sonst Steuerbefehl)
;PA: a: Low-Nibble zum High-Nibble geschafft, Low-Nibble undefiniert
;VR: a,r2
rlc a ;Bit ausschieben
mov DISP_DATA.DATA3_BIT,c ;Bit3 hier einsetzen
rlc a ;Bit ausschieben
mov DISP_DATA.DATA2_BIT,c ;Bit2 dort einsetzen
rlc a ;Bit ausschieben
mov DISP_DATA.DATA1_BIT,c ;dito
rlc a ;Bit ausschieben
mov DISP_DATA.DATA0_BIT,c
mov r2,a
mov a,DISP_CONTROL
orl a,CurDisplay
mov DISP_CONTROL,a ;das setzt die gewünschen Bits
mov a,r2
sjmp disp_disable ;fallende Flanke(n) erzeugen
disp_init_ll:
;LowLevel-Initialisierung des Displays und seines Interfaces
;PE: -
;PA: [CurDisplay] adressiert noch beide Display-Hälften
;VR: a,r2,r4,r5
mov CurDisplay,#E_oben | E_unten ;beide Hälften
clr RS_BIT ;immer "Steuerbefehl"
clr RW_BIT ;immer "schreiben"
mov a,#30h
acall disp_nib_out
mov r4,#4
acall wait
mov a,#30h
acall disp_nib_out
acall wait1
mov a,#30h
acall disp_nib_out
acall wait1
mov a,#20h ; auf Nibble-Betrieb stellen
acall disp_nib_out
acall wait1
mov a,#28h ; "System Set": 2/4 Zeilen
sjmp disp_ctrl_out
;********************************
;** Anzeige: HighLevel-Zugriff **
;********************************
;PUBLIC put_cg, gotoxy, put_xy, Put_Follow, Put_XY_Follow, disp_init
put_cg: ;Zeichen-Bitmap setzen
;PE: a=CG-Adresse (40h=1. Zeichen, 48h=2. Zeichen usw.)
; r3=Anzahl Bytes
; DPTR=Bitmap-Zeiger (ins Code-Segment) 8 Bytes
;PA: DPTR zeigt hinter die 8 Bytes
;VR: a,b,DPTR,r2,r3,[CurDisplay] (danach gotoxy aufrufen!)
mov CurDisplay,#E_oben|E_unten ;beide Chips
acall disp_ctrl_out ; "CG-Adresse setzen"
pu_cg_next:
clr a
movc a,@a+dptr
inc dptr
acall disp_char_out
djnz r3,pu_cg_next
ret
gotoxy:
;PE: R3=Spalte (Bits 0..5) und Zeile (Bits 6 und 7)
;PA: [CurDisplay]=Zeichen-Ausgabe-"Adresse" für folgende byt_out-Aufrufe
;VR: a,r2
mov CurDisplay,#E_oben
mov a,r3 ;r3 legt fest E_oben oder E_unten mit Bit 7
anl a,#80h
jz pu_1 ;E_oben oder E_unten?
mov CurDisplay,#E_unten
pu_1: mov a,r3
orl a,#80h ; Adress-Befehl zusammensetzen
sjmp disp_ctrl_out ; "CC-Adresse setzen"
;gotoxy ENDP
put_xy: ;String-Ausgabe aus Codesegment
;PE: r3=Ausgabe-Adresse (0=1. Zeile, 40h=2. Zeile, 80h=3. Zeile, C0h=4. Zeile)
; DPTR=String-Zeiger (im Code-Segment)
;PA: DPTR zeigt hinter die Null
;VR: a=0,DPTR,r2
acall gotoxy
sjmp put_string
put_string_loop:
acall disp_char_out
put_string:
clr a
movc a,@a+dptr
inc dptr
jnz put_string_loop ;(noch ein) Zeichen ausgeben
ret
Put_Follow:
;Ausgabe konstanter ASCIIZ-String, der nach dem Unterprogramm-Aufruf
;notiert wird
;PE: - (CurDisplay muss durch einen Aufruf von gotoxy stehen)
;PA: -
;VR: a=0,dptr,r2
pop DPH
pop DPL
acall put_string
jmp @a+dptr ;zurück zum Aufrufer (wirklich!)
Put_XY_Follow:
;wie "gotoxy" und "Put_Follow" zusammen
;PE: R3 = Position
;PA: -
;VR: a=0,dptr,r2
pop DPH
pop DPL
acall put_xy
jmp @a+dptr ;zurück zum Aufrufer (wirklich!)
disp_init:
;HighLevel-Initialisierung: Modus setzen u.ä.
mov a,#08h
acall disp_ctrl_out
mov a,#01h
acall disp_ctrl_out
mov a,#06h
acall disp_ctrl_out
mov a,#00001100b ;Cursors blinken usw.
ajmp disp_ctrl_out
;********************************************************
;** Anzeige: Anwendungs-orientierte Routinen und Daten **
;********************************************************
;Hallo2: .dc.b 1,9," Tr",0E1h,"nen",0F5h,"berstr",0EFh,"mt ",0e4h,"F k",8,0
;Hallo3: .dc.b "µ@#+*'€^^ ",0
;ein paar "hübsche" (fehlende) Zeichen fürs Display
ZG0: .dc.b 01110b ;SYMBOL großes Ohm
.dc.b 10001b ; (das kleine sieht ja hässlich aus!)
.dc.b 10001b
.dc.b 10001b
.dc.b 01010b
.dc.b 01010b
.dc.b 11011b
.dc.b 00000b ;Cursorzeile
ZG1: .dc.b 10001b ;LATIN1 großes Ä
.dc.b 00100b
.dc.b 01010b
.dc.b 10001b
.dc.b 11111b
.dc.b 10001b
.dc.b 10001b
.dc.b 00000b ;Cursorzeile
ZG2: .dc.b 10001b ;LATIN1 großes Ö
.dc.b 01110b
.dc.b 10001b
.dc.b 10001b
.dc.b 10001b
.dc.b 10001b
.dc.b 01110b
.dc.b 00000b ;Cursorzeile
ZG3: .dc.b 10001b ;LATIN1 großes Ü
.dc.b 00000b ;(auch das kleine ü sieht blöd aus)
.dc.b 10001b
.dc.b 10001b
.dc.b 10001b
.dc.b 10001b
.dc.b 01110b
.dc.b 00000b ;Cursorzeile
ZG4: .dc.b 00111b ;WIN1250 Euro-Symbol (hä?)
.dc.b 01000b
.dc.b 11111b
.dc.b 10000b
.dc.b 11110b
.dc.b 10000b
.dc.b 01110b
.dc.b 00000b ;Cursorzeile
ZG5: .dc.b 00000b ;ASCII Backslash \
.dc.b 10000b
.dc.b 01000b
.dc.b 00100b
.dc.b 00010b
.dc.b 00001b
.dc.b 00000b
.dc.b 00000b ;Cursorzeile
ZG6: .dc.b 00000b ;ASCII Schlange/Tilde ~
.dc.b 00000b
.dc.b 10110b
.dc.b 01101b
.dc.b 00000b
.dc.b 00000b
.dc.b 00000b
.dc.b 00000b ;Cursorzeile
Prepare_Display:
mov r3,#0*64+0 ;oben links
acall Put_XY_Follow
.dc.b "Temperatur + Feuchtemessung",0
;Spalte mit 3x "°C" ausgeben
mov r3,#1*64+13 ;Zeile 1 = 2. Zeile
ph1: acall Put_XY_Follow
.dc.b 0DFh,"C",0
mov a,r3
add a,#1*64 ;1 Zeile runter
mov r3,a
jnc ph1
;Spalte mit 3x "%rF" ausgeben
mov r3,#1*64+24 ;ganz hinten
ph2: acall Put_XY_Follow
.dc.b "%rF",0
mov a,r3
add a,#1*64 ;1 Zeile runter
mov r3,a
jnc ph2
;"Min" und "Max" ausgeben
mov r3,#2*64+0
acall Put_XY_Follow
.dc.b "Min:",0
mov r3,#3*64+0
acall Put_XY_Follow
.dc.b "Max:",0
ret
itoa:
;PE: r4=auszugebende 8-bit-Zahl
mov r3,#0
mov a,r4
itoa_1: mov B,#10
div ab
push B
inc r3
jnz itoa_1
itoa_2:
pop ACC
add a,#'0'
acall disp_char_out
djnz r3,itoa_2
ret
FixOut16: ;PROC
;Ausgabe einer 16-bit-Festkommazahl
;PE: r7:r6 = 16-bit-Zahl vzb.
; Fix_Feldb = Feldbreite
; Fix_Dezim = Anzahl Dezimalstellen
; Fix_Flags = weitere Steuerbits... (???)
;PA: -
;VR: r3=0,r4,r5=0,r6=0,r7=0
mov a,r7
rlc a
mov Fix_Flags.7,c ;Vorzeichen-Merker
jnc do_6
clr c
clr a
subb a,r6 ;Zweierkomplement
mov r6,a
clr a
subb a,r7
mov r7,a
do_6: mov r3,#0
do_3: mov r5,#16
mov r4,#0
do_2: ;Dividend R4:R7:R6 linksschieben
mov a,r6
rlc a
mov r6,a
mov a,r7
rlc a
mov r7,a
mov a,r4
rlc a
mov r4,a
;Bedingte Subtraktion von 10 von R4
add a,#-10
jnc do_1
mov r4,a
do_1: ;cpl c
mov a,r6 ;CY ins Bit 0 setzen
rr a
rlc a
mov r6,a
djnz r5,do_2
;nach der Division: R4 = Rest, R7:R6=Quotient
do_8: push 4
inc r3
mov a,r3
cjne a,Fix_Dezim,do_7
mov r4,#'.'-'0'
push 4 ;Punkt einpushen
inc r3
do_7: mov a,r6
orl a,r7
jnz do_3
mov r4,#0
mov a,r3 ;bspw. =3 bei 2 Dezimalstellen ist (noch) nicht OK
dec a
setb c
subb a,Fix_Dezim
jc do_8
jnb Fix_Flags.7,do_9
mov r4,#'-'-'0'
push 4
inc r3
;ab hier wird gepoppt und ausgegeben
do_9: setb c
mov a,Fix_Feldb
subb a,r3
jc do_4
inc a
mov r4,a
do_5: mov a,#' '
acall disp_char_out ;führende Leerzeichen
djnz r4,do_5
do_4:
pop ACC
add a,#'0'
acall disp_char_out
djnz r3,do_4
ret
;DezOut16 ENDP
SaveFixOut16XY:
acall gotoxy
SaveFixOut16:
push 3
push 6
push 7
acall FixOut16
pop 7
pop 6
pop 3
ret
HexOut: ;PROC
;PE: A=auszugebende Hex-Zahl, R2 siehe nib_out
;PA: -
;VR: A
push ACC
swap a
acall NibOut
pop ACC
NibOut: ;gibt Low-Nibble von A hexadezimal aus
anl a,#0Fh
add a,#90h
da a
addc a,#40h
da a ;auf wundersame Weise wird so aus 0..F ein '0'..'F'
ajmp disp_char_out
;HexOut ENDP
Mul16x16: ;PROC
;PE: R5:R4 = Faktor 1 (vzl.)
; R7:R6 = Faktor 2 (vzl.)
;PA: [Produkt] = Produkt
;VR: a
;1.
mov a,r4
mov B,r6
mul ab
mov Produkt,a
mov Produkt+1,B
;2.
mov a,r5
mov B,r7
mul ab
mov Produkt+2,a
mov Produkt+3,B
;3.
mov a,r4
mov B,r7
acall mu2
mov a,r5
mov B,r6
mu2: mul ab
add a,Produkt+1
mov Produkt+1,a
mov a,B
addc a,Produkt+2
mov Produkt+2,a
jnc mu1
inc Produkt+3
mu1: ret
;Mul16x16 ENDP
;*******************
;** SHT11-Zugriff **
;*******************
SHT11_ConnReset: ;PROC
;Reset- und Startsequenz für SHT11 ausgeben --> muss das sein??
;PE: - (DATA=H, SCL=L)
;PA: - (DATA=H, SCL=L)
;VR: r5=0
;ALLE__ Zeiten sind evtl viel zu lang!
mov r5,#10
setb DATA
abcd:
setb SCK
setb DATA
nop
clr SCK
setb DATA
nop
djnz r5,abcd
SHT11_Start:
setb SCK
nop
nop
clr DATA
nop
nop
clr SCK
nop
nop
setb SCK
nop
nop
setb DATA
nop
nop
clr SCK ;Ende SHT_Start
ret
;SHT11_ConnReset ENDP
SHT11_ByteOut: ;PROC
;(Kommando-) Byte ausgeben und Acknowledge abholen
;PE: A=Kommando-Byte (DATA=H, SCL=L)
;PA: CY=1 wenn Fehler, CY=0 wenn Ack-Bit OK (DATA=H, SCL=L)
;VR: R5=0,a
;Zähler mit 8 Laden
mov r5,#8
SHT11_ByteOut_Loop:
rlc a ;Bits ausschieben
mov DATA,c ;Datenbit setzen oder rücksetzen
setb SCK ;Takt=H
nop
clr SCK ;Takt=L
setb DATA
djnz r5,SHT11_ByteOut_Loop
;SHT11ack:
setb SCK
nop
mov C,DATA
;!!!!!!!!Wenn SHT11_DATA = 1 wird, alles ok!
clr SCK
setb DATA
ret
;SHT11_ByteOut ENDP
SHT11_ByteIn: ;PROC
;PE: a=0: weiteres Byte anfordern (Bit 0)
; a=1: kein weiteres Byte anfordern
;PA: a=gelesenes Byte
mov r5,#8
SHT11_ByteIn_Loop:
setb SCK
setb DATA
nop
nop
mov c,DATA
rlc a
clr SCK
setb DATA
djnz r5,SHT11_ByteIn_Loop
;Quittungsbit
mov DATA,c ;aus A gekommen
setb SCK
nop
nop
clr SCK
setb DATA
ret
;SHT11_ByteIn ENDP
SHT11_Get_Messwert: ;proc
;PE: r6=5 für %rF, =3 für Temperatur
;PA: r7:r6=Messwert vom SHT11
; CY=1 wenn kein Messwert lieferbar
;VR: r7,r6,r4,r5=0,a
acall SHT11_Start
mov a,r6
acall SHT11_ByteOut
jc SHT11_raus
mov r4,#0 ;256 ms warten
acall wait
setb C
jb DATA,SHT11_raus ;wenn SHT11 immer noch nicht fertig
clr a ;weitere Daten anfordern
acall SHT11_ByteIn
mov r7,a ;High-Byte %rF
mov a,#1 ;keine weiteren Daten (Prüfsumme) anfordern
acall SHT11_ByteIn
mov r6,a ;Low-Byte %rF
clr C
SHT11_raus:
ret
;SHT11_Get_Messwert endp
Calc_Feuchte: ;PROC
;PE: R7:R6=Wert vom Sensor ("SO(RH)")
;PA: R7:R6=Feuchte in Hundertstel Prozent (Festkomma)
;VR: R4,R5
push 2
push 3
;linearer Summand
mov r4,#(1037 & 0FFh) ;LOW(4.05*256)
mov r5,#(1037 >> 8) ;HIGH()
acall Mul16x16
mov r2,Produkt+1 ;"mittlerer" Teil, entspr. /256
mov r3,Produkt+2
;quadratischer Summand
mov r4,6
mov r5,7
acall Mul16x16 ;Quadrat
mov r4,#(4698 & 0FFh) ;0.07168*64K
mov r5,#(4698 >> 8)
mov r6,Produkt+1 ;"mittlerer" Teil, /256
mov r7,Produkt+2
acall Mul16x16
;subtrahieren
clr c
mov a,r2
subb a,Produkt+2 ;"oberer" Teil, /64K
mov r2,a
mov a,r3
subb a,Produkt+3
mov r3,a
;konstanter Summand
mov a,r2
add a,#(-400 & 0FFh)
mov r6,a
mov a,r3
addc a,#(-400 >> 8)
mov r7,a
pop 3
pop 2
ret
;Calc_Feuchte ENDP
InitAllMinMax:
;initialisiert TMinMax und FMinMax (aufeinanderfolgend!)
;PE: - PA: - VR: R0
mov r0,#TMinMax
acall InitMinMax
InitMinMax:
;initialisiert zwei aufeinanderfolgende WORDs mit MAXINT und -MAXINT
mov @r0,#0FFh
inc r0
mov @r0,#07Fh
inc r0
mov @r0,#000h
inc r0
mov @r0,#080h
inc r0
ret
MakeMinMax:
;Berechnet neue Minima und Maxima und gibt diese bei Veränderung aus
;PE: R3 = Cursor-Spalte (Bit 5:0), Zeile=1
; R7:R6 = aktueller Messwert
; R0 = Zeiger auf Minimum-WORD (LOW) und Maximum-WORD (HIGH), d.h.
; [R0]=LOW Minimum, [R0+1]=HIGH Minimum, [R0+2]=LOW Maximum usw.
;PA: -
;VR: R0,R2,R3
clr c
mov a,r6
subb a,@r0
inc r0
mov a,r7
subb a,@r0
jnb PSW.2,mmm1 ;=OV
cpl a
mmm1: jnb ACC.7,NoNewMin
mov a,r7
mov @r0,a
dec r0
mov a,r6
mov @r0,a
inc r0
mov a,r3
anl a,#03Fh ;Spalte stehen lassen
orl a,#2*64 ;Zeile 2
mov r3,a
acall SaveFixOut16XY
NoNewMin:
inc r0 ;jetzt zeigt R0 aufs Maximum
clr c
mov a,@r0
subb a,r6
inc r0
mov a,@r0
subb a,r7
swap a ;sprungfreie Version, genauso lang
rr a
xrl a,PSW
jnb ACC.2,NoNewMax
mov a,r7
mov @r0,a
dec r0
mov a,r6
mov @r0,a
mov a,r3
anl a,#03Fh ;Spalte stehen lassen
orl a,#3*64 ;Zeile 3
mov r3,a
acall SaveFixOut16XY
NoNewMax:
ret
NoFixOutXY:
;Ausgabe KEINER Zahl bei Interface-Problem mit dem SHT11
acall Put_XY_Follow
.dc.b " ---.--",0
ret
init:
mov SP,#07Fh
acall disp_init_ll ;LowLevel-Initialisierung
acall disp_init ;HighLevel-Init.
mov DPTR,#ZG0 ;großes Ohm, Ä, Ö, Ü, Euro, \, ~
mov a,#40h ;Adress-Befehl: Adresse 0
mov r3,#8*7 ;7 aufeinanderfolgende Zeichen
lcall put_cg
lcall Prepare_Display
mov Fix_Feldb,#7
mov Fix_Dezim,#2
mov Num_Messung,#0
acall InitAllMinMax
MainLoop:
mov r3,#1*64+1
acall gotoxy
inc Num_Messung
mov a,Num_Messung
acall HexOut
;Temperatur einlesen, umrechnen und ausgeben
mov r6,#%00000011 ;Kommando: Temperatur
acall SHT11_Get_Messwert
mov r3,#1*64+5
jc NoTemp
mov a,r6
add a,#(-4000 & 0FFh)
mov r6,a
mov a,r7
addc a,#(-4000 >>8)
mov r7,a
acall SaveFixOut16XY
mov r0,#TMinMax
acall MakeMinMax ;übernimmt auch R3
sjmp TempOK
NoTemp: acall NoFixOutXY
TempOK: ;Feuchte einlesen, umrechnen und ausgeben
mov r6,#%00000101 ;Kommando: %rF
acall SHT11_Get_Messwert
mov r3,#1*64+16
jc NoHumi
acall Calc_Feuchte ;"umrechnen" in Prozent
acall SaveFixOut16XY
mov r0,#FMinMax
acall MakeMinMax ;übernimmt auch R3
sjmp HumiOK
NoHumi: acall NoFixOutXY
HumiOK:
;mov a,r7
;acall HexOut
;mov a,r6
;acall HexOut
mov r4,#0
acall wait ;256 ms (Maximum) verbraten
mov P1,#128
mov a,P6 ;P6 ist leider nicht bitadressierbar
jb ACC.0,MainLoop
acall InitAllMinMax ;mit der Taste an P6.0 Minima/Maxima rücksetzen
sjmp MainLoop
END:
Detected encoding: UTF-8 | 0
|